home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume90 / aplictns / plplot26 / part07 < prev    next >
Encoding:
Text File  |  1990-01-14  |  55.9 KB  |  1,605 lines
  1. Path: xanth!cs.odu.edu!Amiga-Request
  2. From: Amiga-Request@cs.odu.edu (Amiga Sources/Binaries Moderator)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v90i008: plplot 2.6 - C library for making scientific plots, Part07/12
  5. Message-ID: <10980@xanth.cs.odu.edu>
  6. Date: 14 Jan 90 23:30:34 GMT
  7. Sender: tadguy@cs.odu.edu
  8. Reply-To: Anthony M. Richardson <amr@dukee.egr.duke.edu>
  9. Lines: 1593
  10. Approved: tadguy@cs.odu.edu (Tad Guy)
  11.  
  12. Submitted-by: Anthony M. Richardson <amr@dukee.egr.duke.edu>
  13. Posting-number: Volume 90, Issue 008
  14. Archive-name: applications/plplot-2.6/part07
  15.  
  16. #! /bin/sh
  17. # This is a shell archive.  Remove anything before this line, then unpack
  18. # it by saving it into a file and typing "sh file".  To overwrite existing
  19. # files, type "sh file -c".  You can also feed this as standard input via
  20. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  21. # will see the following message at the end:
  22. #        "End of archive 7 (of 12)."
  23. # Contents:  docs/chapter2.tex include/plplot.h src/plbox.c
  24. #   src/plnxtv.c
  25. # Wrapped by tadguy@xanth on Sun Jan 14 18:11:52 1990
  26. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  27. if test -f 'docs/chapter2.tex' -a "${1}" != "-c" ; then 
  28.   echo shar: Will not clobber existing file \"'docs/chapter2.tex'\"
  29. else
  30. echo shar: Extracting \"'docs/chapter2.tex'\" \(10944 characters\)
  31. sed "s/^X//" >'docs/chapter2.tex' <<'END_OF_FILE'
  32. X\chapter {Simple Use of PLPLOT} \label{simple}
  33. X
  34. XThe rest of this manual assumes the reader has some familiarity with the
  35. XC programming language.
  36. X
  37. X\section {Notation}
  38. XSeveral of the plotting routines are described in this section.
  39. XThe values passed to or returned by the functions
  40. Xare either of type char, PLINT, PLFLT or pointers to one of these three
  41. Xtypes. PLINT and PLFLT are typedef'ed in plplot.h. PLINT is usually
  42. Xtypedef'ed to the longest available interger type (long). PLFLT is
  43. Xtypedef'ed to either float or double (see your local PLPLOT guru to
  44. Xfind out which!!).
  45. X
  46. X\section {Plotting a Simple Graph}
  47. XWe shall first consider plotting simple graphs showing the dependence
  48. Xof one variable upon another. Such a graph may be composed of several
  49. Xelements:
  50. X\begin{itemize}
  51. X   \item A box which defines the ranges of the variables, perhaps with axes
  52. X         and numeric labels along its edges,
  53. X   \item A set of points or lines within the box showing the functional
  54. X         dependence,
  55. X   \item A set of labels for the variables and a title for the graph.
  56. X\end{itemize}
  57. XIn order to draw such a graph, it is necessary to call at least four of
  58. Xthe PLPLOT functions:
  59. X\begin{enumerate}
  60. X   \item {\tt plstar}, to specify the device you want to plot on,
  61. X   \item {\tt plenv}, to define the range and scale of the graph, and
  62. X                      draw labels, axes, etc.,
  63. X   \item One or more calls to {\tt plline} or {\tt plpoin} to draw
  64. X         lines or points as needed. Other more complex routines include
  65. X         {\tt plbin} and {\tt plhist} to draw histograms, {\tt plerrx} and
  66. X         {\tt plerry} to draw error-bars, \label{draw}
  67. X   \item {\tt plend}, to close the plot.
  68. X\end{enumerate}
  69. XMore than one graph can be drawn on a single set of axes by making
  70. Xrepeated calls to the routines listed in item \ref{draw} above. The routine
  71. X{\tt plstar} needs to be called only once, unless it is desired to switch
  72. Xoutput devices between pages.
  73. X
  74. X\section {Starting PLPLOT} \label{startingup}
  75. XSubroutine {\tt plstar} selects a graphics device or opens a disk file to
  76. Xreceive a plot for later display. If {\tt plstar} is called again during
  77. Xa program, the previously opened file will be closed. When called,
  78. Xthe user is prompted for a number representing the device on which
  79. Xthe plot is to appear. The syntax for {\tt plstar} is:
  80. X
  81. X\name{plstar(nx,ny);}
  82. X\argu{{\tt nx, ny} (PLINT, input)}
  83. X{The number of plots to a page. The page is divided into
  84. X{\tt nx}~$\times$~{\tt ny} subpages, with {\tt nx} in the horizontal
  85. Xdirection, and {\tt ny} in the vertical direction.}
  86. X
  87. XSubpages are useful for placing several graphs on a page, but all
  88. Xsubpages are constrained to be of the same size. For greater flexibility,
  89. Xread page \pageref{viewport} in Section
  90. X\ref{viewport} which discusses viewports.
  91. X
  92. X\section{Defining Plot Scales and Axes}
  93. XThe function {\tt plenv} is used to define the scales and axes for simple
  94. Xgraphs. {\tt plenv} starts a new picture on the next subpage (or a new page
  95. Xif necessary), and defines the ranges of the variables required. The
  96. Xroutine will also draw a box, axes, and numeric labels if requested.
  97. XThe syntax for {\tt plenv} is:
  98. X
  99. X\name{plenv(xmin,xmax,ymin,ymax,just,axis);}
  100. X\argu{{\tt xmin, xmax} (PLFLT, input)}
  101. X{The left and right limits for the horizontal axis.}
  102. X\argu{{\tt ymin, ymax} (PLFLT, input)}
  103. X{The bottom and top limits for the vertical axis.}
  104. X\argu{{\tt just} (PLINT, input)}
  105. X{This should be zero or one. If {\tt just} is one, the scales of the
  106. Xx-axis and
  107. Xy-axis will be the same (in units per millimeter); otherwise the axes are
  108. Xscaled independently. This parameter is useful for ensuring that objects
  109. Xsuch as circles have the correct aspect ratio in the final plot.}
  110. X\argu{{\tt axis} (PLINT, input)}
  111. X{{\tt axis} controls whether a box, tick marks, labels, axes, and/or a
  112. Xgrid are drawn.
  113. X\begin{itemize}
  114. X     \item {\tt axis=-2}: No box or annotation.
  115. X     \item {\tt axis=-1}: Draw box only.
  116. X     \item {\tt axis= 0}: Draw box, labelled with coordinate values around edge.
  117. X     \item {\tt axis= 1}: In addition to box and labels, draw the two axes
  118. X                          X=0 and Y=0.
  119. X     \item {\tt axis= 2}: As for {\tt axis=1}, but also draw a grid at the major tick interval.
  120. X     \item {\tt axis=10}: Logarithmic X axis, linear Y axis.
  121. X     \item {\tt axis=11}: Logarithmic X axis, linear Y axis and draw line Y=0.
  122. X     \item {\tt axis=20}: Linear X axis, logarithmic Y axis.
  123. X     \item {\tt axis=21}: Linear X axis, logarithmic Y axis and draw line X=0.
  124. X     \item {\tt axis=30}: Logarithmic X and Y axes.
  125. X\end{itemize}
  126. X}
  127. X
  128. XNote: Logarithmic axes only affect the appearance of the axes and their
  129. Xlabels, so it is up to the user to compute the logarithms prior to passing
  130. Xthem to {\tt plenv} and any of the other routines. Thus, if a graph has a 3-cycle
  131. Xlogarithmic axis from 1 to 1000, we need to set {\tt xmin}$=\log_{10}1=0.0$,
  132. Xand {\tt xmax}$=\log_{10}1000=3.0$.
  133. X
  134. XFor greater control over the size of the plots, axis labelling and tick
  135. Xintervals, more complex graphs should make use of the functions
  136. X\rou{plvpor}, \rou{plwind}, and \rou{plbox}
  137. Xdescribed in Chapter \ref{reference}.
  138. X
  139. X\section {Labelling the Graph}
  140. XThe function {\tt pllab} may be called after {\tt plenv} to write labels
  141. Xon the x and y axes, and at the top of the picture. All the
  142. Xvariables are character variables or constants. Trailing spaces
  143. Xare removed and the label is centred in the appropriate field.
  144. XThe syntax for {\tt pllab} is:
  145. X
  146. X\name{pllab(xlbl,ylbl,toplbl);}
  147. X\argu{{\tt xlbl} (char *, input)}
  148. X{Pointer to string with label for the X-axis (bottom of graph).}
  149. X\argu{{\tt ylbl} (char *, input)}
  150. X{Pointer to string with label for the Y-axis (left of graph).}
  151. X\argu{{\tt toplbl} (char *, input)}
  152. X{Pointer to string with label for the plot (top of picture).}
  153. X
  154. XMore complex labels can be drawn using the function \rou{plmtex}.
  155. XSee also Section \ref{graph-text} on page
  156. X\pageref{graph-text} for information about the function {\tt plptex} which
  157. Xwrites labels within a graph.
  158. X
  159. X\section {Drawing the Graph}
  160. X
  161. XPLPLOT can draw graphs consisting of points with optional error bars,
  162. Xline segments or histograms. Functions which perform each of these
  163. Xactions may be called after setting up the plotting environment
  164. Xusing {\tt plenv}. All of the following functions draw within the box
  165. Xdefined by {\tt plenv}, and any lines crossing the boundary are clipped.
  166. XFunctions are also provided for drawing surface and contour representations
  167. Xof multi-dimensional functions. These are described in
  168. XChapter \ref{advanced}.
  169. X
  170. X\subsection {Drawing Points}
  171. X{\tt plpoin} and {\tt plsym} mark out {\tt n} points
  172. X{\tt (x[i],y[i])} with the
  173. Xspecified symbol. The routines differ only in the interpretation
  174. Xof the symbol
  175. Xcodes. {\tt plpoin} uses an extended ASCII representation, with the
  176. Xprintable
  177. XASCII codes mapping to the respective characters in the current font, and
  178. Xthe codes from 0-31 mapping to various useful symbols.
  179. XIn {\tt plsym} however,
  180. Xthe code is a Hershey font code number. Example programs are provided
  181. Xwhich display each of the symbols available using these routines.
  182. X
  183. X\name{plpoin(n,x,y,code); {\rm and } plsym(n,x,y,code);}
  184. X\argu{{\tt n} (PLINT, input)}
  185. X{the number of points to plot.}
  186. X\argu{{\tt x, y} (PLFLT *, input)}
  187. X{pointers to arrays of the coordinates of the {\tt n} points.}
  188. X\argu{{\tt code} (PLINT, input)}
  189. X{code number of symbol to draw.}
  190. X
  191. X\subsection {Drawing Lines or Curves}
  192. X
  193. XPLPLOT provides two functions for drawing line graphs.
  194. XAll lines are drawn in
  195. Xthe currently selected color, style and width. See page \pageref{color} in
  196. XSection \ref{color}, page \pageref{style} in Section \ref{style} and
  197. Xpage \pageref{width} in Section \ref{width} for
  198. Xinformation about changing these parameters.
  199. X
  200. X{\tt plline} draws a line or curve. The curve consists of {\tt n-1} line
  201. Xsegments joining the {\tt n} points in the input arrays. For single line
  202. Xsegments, {\tt pljoin} is used to join two points.
  203. X
  204. X\name{plline(n,x,y);}
  205. X\argu{{\tt n} (PLINT, input)}
  206. X{the number of points.}
  207. X\argu{{\tt x, y} (PLFLT *, input)}
  208. X{pointers to arrays with coordinates of the {\tt n} points.}
  209. X
  210. X\name{pljoin(x1,y1,x2,y2);}
  211. X\argu{{\tt x1, y1} (PLFLT, input)}
  212. X{coordinates of the first point.}
  213. X\argu{{\tt x2, y2} (PLFLT, input)}
  214. X{coordinates of the second point.}
  215. X
  216. X\subsection {Writing Text on a Graph} \label {graph-text}
  217. X
  218. X{\tt plptex} allows text to be written within the limits set by
  219. X{\tt plenv}. The reference point of a text string may be located
  220. Xanywhere along an imaginary horizontal line passing through the string
  221. Xat half the height of a capital letter. The parameter "just" specifies
  222. Xwhere along this line the reference point is located. The string is then
  223. Xrotated about the reference point through an angle specified by the
  224. Xparameters {\tt dx} and {\tt dy}, so that the string becomes parallel
  225. Xto a line joining {\tt (x,y)} to {\tt (x+dx,y+dy)}.
  226. X
  227. X\name{plptex(x,y,dx,dy,just,text);}
  228. X\argu{{\tt x, y} (PLFLT, input)}
  229. X{coordinates of the reference point.}
  230. X\argu{{\tt dx, dy} (PLFLT, input)}
  231. X{these specify the angle at which the text is to be printed. The text is
  232. X written parallel to a line joining the points {\tt (x,y)} to
  233. X {\tt (x+dx,y+dy)} on the graph.}
  234. X\argu{{\tt just} (PLFLT, input)}
  235. X{determines justification of the string by specifying which point within
  236. X the string is placed at the reference point {\tt (x,y)}. This parameter
  237. X is a fraction of the distance along the string. Thus if {\tt just=0.0},
  238. X the reference point is at the left-hand edge of the string.
  239. X If {\tt just=0.5}, it is at the center and if {\tt just=1.0}, it is at
  240. X the right-hand edge.}
  241. X\argu{{\tt text} (char *, input)}
  242. X{pointer to the string of characters to be written.}
  243. X
  244. X\subsection {Area Fills}
  245. X
  246. XArea fills are done in
  247. Xthe currently selected color, line style, line width and pattern style.
  248. X
  249. X{\tt plfill} fills a polygon. The polygon consists of {\tt n}
  250. Xvertices which define the polygon.
  251. X
  252. X\name{plfill(n,x,y);}
  253. X\argu{{\tt n} (PLINT, input)}
  254. X{the number of vertices.}
  255. X\argu{{\tt x, y} (PLFLT *, input)}
  256. X{pointers to arrays with coordinates of the {\tt n} vertices.}
  257. X
  258. X
  259. X\subsection {More Complex Graphs (Histograms and Error Bars)}
  260. X
  261. XFunctions \rou{plbin} and \rou{plhist} are provided for
  262. Xdrawing histograms, and functions \rou{plerrx}
  263. Xand \rou{plerry} draw error bars about specified
  264. Xpoints. They are described in detail in Chapter \ref{reference}.
  265. X
  266. X\section {Finishing Up}
  267. X
  268. XBefore the end of the program, ALWAYS call \rou{plend}
  269. Xto close any output plot files and to free up resources.
  270. XFor devices that have separate graphics
  271. Xand text modes, {\tt plend} resets the device to text mode.
  272. X
  273. X\section {In Case of Error}
  274. X
  275. XIf a fatal error is encountered during execution of a PLPLOT routine
  276. Xthen \rou{plexit} is called. This routine prints an error message,
  277. Xdoes resource recovery, calls {\tt pl\_exit} (page~\pageref{plxexit}) 
  278. Xand then exits. The
  279. Xdefault {\tt pl\_exit} routine does nothing, but the user may wish
  280. Xto supply his/her own version of {\tt pl\_exit}.
  281. X
  282. END_OF_FILE
  283. if test 10944 -ne `wc -c <'docs/chapter2.tex'`; then
  284.     echo shar: \"'docs/chapter2.tex'\" unpacked with wrong size!
  285. fi
  286. # end of 'docs/chapter2.tex'
  287. fi
  288. if test -f 'include/plplot.h' -a "${1}" != "-c" ; then 
  289.   echo shar: Will not clobber existing file \"'include/plplot.h'\"
  290. else
  291. echo shar: Extracting \"'include/plplot.h'\" \(13579 characters\)
  292. sed "s/^X//" >'include/plplot.h' <<'END_OF_FILE'
  293. X/* This header file contains all of the function prototypes and
  294. X   machine dependent defines */
  295. X
  296. X/* We need to know where the fonts are located, so set these. */
  297. X#ifdef AMIGA
  298. X  #define SSTRKFONT  "PLFONTS:plstnd.fnt"
  299. X  #define SFONTINDX  "PLFONTS:plstnd.idx"
  300. X  #define SFONTLKUP  "PLFONTS:plstnd.lkp"
  301. X  #define XSTRKFONT  "PLFONTS:plxtnd.fnt"
  302. X  #define XFONTINDX  "PLFONTS:plxtnd.idx"
  303. X  #define XFONTLKUP  "PLFONTS:plxtnd.lkp"
  304. X#endif
  305. X
  306. X/* plfontld.c is the only file that uses these defines. So if you
  307. X   move the fonts, just change these and recompile plfontld.c */
  308. X#ifdef unix
  309. X  #define SSTRKFONT  "/home/dukee2/amr/newplp/fonts/plstnd.fnt" 
  310. X  #define SFONTINDX  "/home/dukee2/amr/newplp/fonts/plstnd.idx"
  311. X  #define SFONTLKUP  "/home/dukee2/amr/newplp/fonts/plstnd.lkp"
  312. X  #define XSTRKFONT  "/home/dukee2/amr/newplp/fonts/plxtnd.fnt"
  313. X  #define XFONTINDX  "/home/dukee2/amr/newplp/fonts/plxtnd.idx"
  314. X  #define XFONTLKUP  "/home/dukee2/amr/newplp/fonts/plxtnd.lkp"
  315. X#endif
  316. X
  317. X/* If PLDBL is defined all floating point variables will be of type double */
  318. X#ifdef PLDBL
  319. X   typedef double PLFLT;
  320. X#else
  321. X   typedef float PLFLT;
  322. X#endif
  323. X
  324. X/* You'd better leave this as is. I haven't gotten around to seeing
  325. X   if things will work with short's. I doubt that they will. */
  326. Xtypedef long PLINT;
  327. X
  328. X#ifdef LATTICE_50
  329. X   #define PLSTDC             1
  330. X#endif
  331. X
  332. X#ifdef __STDC__
  333. X   #define PLSTDC             1
  334. X#endif
  335. X
  336. X/* We need a signed char type. Manx doesn't support signed char but
  337. X   fortunately treats char as signed. */
  338. X#ifndef AZTEC_C 
  339. X   typedef signed char SCHAR;
  340. X#else
  341. X   typedef char        SCHAR;
  342. X#endif
  343. X
  344. X/* Let's try to get around some ANSI/non-ANSI problems with typedef's */
  345. X/* PLPLOT needs a signed char type to work. Some compilers don't
  346. X   recognize the signed char keywords however. */
  347. X#ifdef PLSTDC
  348. X   typedef void        VOID;
  349. X#else
  350. X   typedef char        VOID;
  351. X#endif
  352. X
  353. X#ifdef PLSTDC
  354. X   #define PLARGS(a)  a       /* Use function prototypes. */
  355. X#else
  356. X   #define PLARGS(a)  ()
  357. X#endif
  358. X
  359. X#ifdef NOPROTS
  360. X   #undef PLARGS
  361. X   #define PLARGS(a) ()
  362. X#endif
  363. X
  364. X#ifndef max
  365. X   #define max(a,b)     ((a)>(b) ? (a) : (b))
  366. X   #define min(a,b)     ((a)<(b) ? (a) : (b))
  367. X   #define abs(a)       ((a)<0 ? -(a) : (a))
  368. X#endif
  369. X
  370. X#define round(a)   (PLINT)((a)<0. ? ((a)-.5) : ((a)+.5))
  371. X
  372. X/* All of the void type declarations are made first. */
  373. Xvoid pladv PLARGS((PLINT page));
  374. Xvoid plbeg PLARGS((PLINT dev, PLINT nx, PLINT ny));
  375. Xvoid plbin PLARGS((PLINT nbin, PLFLT *x, PLFLT *y, PLINT centre));
  376. Xvoid plbox PLARGS((char *xopt, PLFLT xtick, PLINT nxsub, char *yopt, \
  377. X                   PLFLT ytick, PLINT nysub));
  378. Xvoid plccal PLARGS((PLFLT *pts, PLINT nx, PLINT ny, PLFLT zlev, \
  379. X                    PLINT ix, PLINT iy, PLINT ixg, PLINT iyg, PLFLT *dist));
  380. Xvoid plclr PLARGS((void));
  381. Xvoid plcntr PLARGS((PLFLT *points, PLINT nx, PLINT ny, PLINT kx, PLINT lx, \
  382. X                    PLINT ky, PLINT ly, PLFLT zlev, PLINT *iscan, \
  383. X                    PLINT *ixstor, PLINT *iystor, PLINT nstor, \
  384. X                    void (*tr)(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty)));
  385. Xvoid plcol PLARGS((PLINT color));
  386. Xvoid plcont PLARGS((PLFLT *z, PLINT nx, PLINT ny, PLINT kx, PLINT lx, \
  387. X                    PLINT ky, PLINT ly, PLFLT *clevel, PLINT nlevel, \
  388. X                    void (*tr)()));
  389. Xvoid pldeco PLARGS((short **symbol, PLINT *length, char *text));
  390. Xvoid pldtik PLARGS((PLFLT vmin, PLFLT vmax, PLFLT *tick, PLINT *nsubt, \
  391. X                    PLINT *mode, PLINT *prec));
  392. Xvoid plend PLARGS((void));
  393. Xvoid plenv PLARGS((PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, \
  394. X                   PLINT just, PLINT axis));
  395. Xvoid plerrx PLARGS((PLINT n, PLFLT *xmin, PLFLT *xmax, PLFLT *y));
  396. Xvoid plerry PLARGS((PLINT n, PLFLT *x, PLFLT *ymin, PLFLT *ymax));
  397. Xvoid plerx1 PLARGS((PLFLT xmin, PLFLT xmax, PLFLT y));
  398. Xvoid plery1 PLARGS((PLFLT x, PLFLT ymin, PLFLT ymax));
  399. Xvoid plexit PLARGS((char *msg));
  400. Xvoid plfill PLARGS((PLINT n, PLFLT *x, PLFLT *y));
  401. Xvoid plfont PLARGS((PLINT ifont));
  402. Xvoid plfontld PLARGS((PLINT fnt));
  403. Xvoid plfontrel PLARGS((void));
  404. Xvoid plform PLARGS((PLFLT value, PLINT mode, PLINT prec, char *result));
  405. Xvoid plgra PLARGS((void));
  406. Xvoid plgspa PLARGS((PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax));
  407. Xvoid plhist PLARGS((PLINT n, PLFLT *data, PLFLT datmin, PLFLT datmax, \
  408. X                    PLINT nbin, PLINT oldwin));
  409. Xvoid plhrsh PLARGS((PLINT ch, PLINT x, PLINT y));
  410. Xvoid pljoin PLARGS((PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2));
  411. Xvoid pllab PLARGS((char *xlabel, char *ylabel, char *tlabel));
  412. Xvoid pllclp PLARGS((PLINT x1, PLINT y1, PLINT x2, PLINT y2));
  413. Xvoid plline PLARGS((PLINT n, PLFLT *x, PLFLT *y));
  414. Xvoid pllsty PLARGS((PLINT line));
  415. Xvoid plmtex PLARGS((char *side, PLFLT disp, PLFLT pos, PLFLT just, \
  416. X                    char *text));
  417. Xvoid plpat PLARGS((PLINT n, PLINT *inc, PLINT *del));
  418. Xvoid plpoi1 PLARGS((PLFLT x, PLFLT y, PLINT code));
  419. Xvoid plpoin PLARGS((PLINT n, PLFLT *x, PLFLT *y, PLINT code));
  420. Xvoid plprec PLARGS((PLINT setp, PLINT prec));
  421. Xvoid plpsty PLARGS((PLINT patt));
  422. Xvoid plptex PLARGS((PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, \
  423. X                    char *text));
  424. Xvoid plr135 PLARGS((PLINT *ix, PLINT *iy, PLINT isens));
  425. Xvoid plr45 PLARGS((PLINT *ix, PLINT *iy, PLINT isens));
  426. Xvoid plschr PLARGS((PLFLT dep, PLFLT scale));
  427. Xvoid plselect PLARGS((PLINT ori, char *file));
  428. Xvoid plsetup PLARGS((PLFLT xdpi, PLFLT ydpi, PLINT xw, PLINT yw));
  429. Xvoid plsmaj PLARGS((PLFLT def, PLFLT scale));
  430. Xvoid plsmin PLARGS((PLFLT def, PLFLT scale));
  431. Xvoid plssym PLARGS((PLFLT def, PLFLT scale));
  432. Xvoid plstar PLARGS((PLINT nx, PLINT ny));
  433. Xvoid plstik PLARGS((PLFLT mx, PLFLT my, PLFLT dx, PLFLT dy));
  434. Xvoid plstr PLARGS((PLINT base, PLFLT *xform, PLINT refx, PLINT refy, \
  435. X                  char *string));
  436. Xvoid plstyl PLARGS((PLINT nels, PLINT *mk, PLINT *sp));
  437. Xvoid plsvpa PLARGS((PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax));
  438. Xvoid plsym PLARGS((PLINT n, PLFLT *x, PLFLT *y, PLINT code));
  439. Xvoid plsym1 PLARGS((PLFLT x, PLFLT y, PLINT code));
  440. Xvoid pltext PLARGS((void));
  441. Xvoid plupd PLARGS((void));
  442. Xvoid plvpor PLARGS((PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax));
  443. Xvoid plvsta PLARGS((void));
  444. Xvoid plwid PLARGS((PLINT pwid));
  445. Xvoid plwind PLARGS((PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax));
  446. Xvoid plxtik PLARGS((PLINT x, PLINT y, PLINT below, PLINT above));
  447. Xvoid plxybx PLARGS((char *opt, char *label, PLFLT wx1, PLFLT wy1, \
  448. X                    PLFLT wx2, PLFLT wy2, PLFLT vmin, PLFLT vmax, \
  449. X                    PLFLT tick, PLINT nsub, PLINT nolast));
  450. Xvoid plxytx PLARGS((PLFLT wx1, PLFLT wy1, PLFLT wx2, PLFLT wy2, \
  451. X                    PLFLT disp, PLFLT pos, PLFLT just, char *text));
  452. Xvoid plytik PLARGS((PLINT x, PLINT y, PLINT left, PLINT right));
  453. Xvoid plzbx PLARGS((char *opt, char *label, PLINT right, PLFLT dx, PLFLT dy, \
  454. X                   PLFLT wx, PLFLT wy1, PLFLT wy2, PLFLT vmin, PLFLT vmax, \
  455. X                   PLFLT tick, PLINT nsub));
  456. Xvoid plztx PLARGS((char *opt, PLFLT dx, PLFLT dy, PLFLT wx, PLFLT wy1, \
  457. X                   PLFLT wy2, PLFLT disp, PLFLT pos, PLFLT just, char *t));
  458. X
  459. X/* 3-D routine types*/
  460. Xvoid pl3cut PLARGS((PLINT sx1, PLINT sy1, PLINT sx2, PLINT sy2, PLINT su1, \
  461. X                    PLINT sv1, PLINT su2, PLINT sv2, PLINT *cx, PLINT *cy));
  462. Xvoid plbox3 PLARGS((char *xopt, char *xlabel, PLFLT xtick, PLINT nsubx, \
  463. X                    char *yopt, char *ylabel, PLFLT ytick, PLINT nsuby, \
  464. X                    char *zopt, char *zlabel, PLFLT ztick, PLINT nsubz));
  465. Xvoid plgrid3 PLARGS((PLFLT tick));
  466. Xvoid plmesh PLARGS((PLFLT *x, PLFLT *y, PLFLT *z, PLINT ly, \
  467. X                      PLINT nx, PLINT ny, PLINT opt));
  468. Xvoid plnxtv PLARGS((PLINT *u, PLINT *v, PLINT n, PLINT init));
  469. Xvoid plot3d PLARGS((PLFLT *x, PLFLT *y, PLFLT *z, PLINT ly, \
  470. X                      PLINT nx, PLINT ny, PLINT opt, PLINT side));
  471. Xvoid plside3 PLARGS((PLFLT *x, PLFLT *y, PLFLT *z, PLINT ly, PLINT nx, \
  472. X                       PLINT ny, PLINT opt));
  473. Xvoid plt3zz PLARGS((PLINT xstar0, PLINT ystar0, PLINT dx, PLINT dy, \
  474. X                      PLINT flg0, PLINT init, PLFLT *x, PLFLT *y, PLFLT *z, \
  475. X                      PLINT ly, PLINT nx, PLINT ny, PLINT *u, PLINT *v));
  476. Xvoid plw3d PLARGS((PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0, \
  477. X                     PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0, \
  478. X                     PLFLT zmax0, PLFLT alt, PLFLT az));
  479. X
  480. X/* The novice plplot user will not need to call the following functions */
  481. Xvoid cleanup PLARGS((void));
  482. Xvoid genlin PLARGS((PLINT x1, PLINT y1, PLINT x2, PLINT y2));
  483. Xvoid movphy PLARGS((PLINT x, PLINT y));
  484. Xvoid draphy PLARGS((PLINT x, PLINT y));
  485. Xvoid movwor PLARGS((PLFLT x, PLFLT y));
  486. Xvoid drawor PLARGS((PLFLT x, PLFLT y));
  487. Xvoid setphy PLARGS((PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax));
  488. Xvoid setpxl PLARGS((PLFLT xpmm0, PLFLT ypmm0));
  489. Xvoid setsub PLARGS((void));
  490. Xvoid xform PLARGS((PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty));
  491. X/* stuff in global.c */
  492. Xvoid glev PLARGS((PLINT *n));
  493. Xvoid slev PLARGS((PLINT n));
  494. Xvoid gbase PLARGS((PLFLT *x, PLFLT *y, PLFLT *xc, PLFLT *yc));
  495. Xvoid sbase PLARGS((PLFLT x, PLFLT y, PLFLT xc, PLFLT yc));
  496. Xvoid gnms PLARGS((PLINT *n));
  497. Xvoid snms PLARGS((PLINT n));
  498. Xvoid gdev PLARGS((PLINT *dev, PLINT *term, PLINT *gra));
  499. Xvoid sdev PLARGS((PLINT dev, PLINT term, PLINT gra));
  500. Xvoid smod PLARGS((PLINT term));
  501. Xvoid gcurr PLARGS((PLINT *ix, PLINT *iy));
  502. Xvoid scurr PLARGS((PLINT ix, PLINT iy));
  503. Xvoid gdom PLARGS((PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax));
  504. Xvoid sdom PLARGS((PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax));
  505. Xvoid grange PLARGS((PLFLT *zscl, PLFLT *zmin, PLFLT *zmax));
  506. Xvoid srange PLARGS((PLFLT zscl, PLFLT zmin, PLFLT zmax));
  507. Xvoid gw3wc PLARGS((PLFLT *dxx, PLFLT *dxy, PLFLT *dyx, PLFLT *dyy, PLFLT *dyz));
  508. Xvoid sw3wc PLARGS((PLFLT dxx, PLFLT dxy, PLFLT dyx, PLFLT dyy, PLFLT dyz));
  509. Xvoid gvpp PLARGS((PLINT *ixmin, PLINT *ixmax, PLINT *iymin, PLINT *iymax));
  510. Xvoid svpp PLARGS((PLINT ixmin, PLINT ixmax, PLINT iymin, PLINT iymax));
  511. Xvoid gspp PLARGS((PLINT *ixmin, PLINT *ixmax, PLINT *iymin, PLINT *iymax));
  512. Xvoid sspp PLARGS((PLINT ixmin, PLINT ixmax, PLINT iymin, PLINT iymax));
  513. Xvoid gclp PLARGS((PLINT *ixmin, PLINT *ixmax, PLINT *iymin, PLINT *iymax));
  514. Xvoid sclp PLARGS((PLINT ixmin, PLINT ixmax, PLINT iymin, PLINT iymax));
  515. Xvoid gphy PLARGS((PLINT *ixmin, PLINT *ixmax, PLINT *iymin, PLINT *iymax));
  516. Xvoid sphy PLARGS((PLINT ixmin, PLINT ixmax, PLINT iymin, PLINT iymax));
  517. Xvoid gsub PLARGS((PLINT *nx, PLINT *ny, PLINT *cs));
  518. Xvoid ssub PLARGS((PLINT nx, PLINT ny, PLINT cs));
  519. Xvoid gumpix PLARGS((PLINT *ix, PLINT *iy));
  520. Xvoid sumpix PLARGS((PLINT ix, PLINT iy));
  521. Xvoid gatt PLARGS((PLINT *ifnt, PLINT *icol));
  522. Xvoid satt PLARGS((PLINT ifnt, PLINT icol));
  523. Xvoid gcol PLARGS((PLINT *icol));
  524. Xvoid scol PLARGS((PLINT icol));
  525. Xvoid gwid PLARGS((PLINT *pwid));
  526. Xvoid swid PLARGS((PLINT pwid));
  527. Xvoid gspd PLARGS((PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax));
  528. Xvoid sspd PLARGS((PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax));
  529. Xvoid gvpd PLARGS((PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax));
  530. Xvoid svpd PLARGS((PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax));
  531. Xvoid gvpw PLARGS((PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax));
  532. Xvoid svpw PLARGS((PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax));
  533. Xvoid gpixmm PLARGS((PLFLT *x, PLFLT *y));
  534. Xvoid spixmm PLARGS((PLFLT x, PLFLT y));
  535. Xvoid gwp PLARGS((PLFLT *xscl, PLFLT *xoff, PLFLT *yscl, PLFLT *yoff));
  536. Xvoid swp PLARGS((PLFLT xscl, PLFLT xoff, PLFLT yscl, PLFLT yoff));
  537. Xvoid gwm PLARGS((PLFLT *xscl, PLFLT *xoff, PLFLT *yscl, PLFLT *yoff));
  538. Xvoid swm PLARGS((PLFLT xscl, PLFLT xoff, PLFLT yscl, PLFLT yoff));
  539. Xvoid gdp PLARGS((PLFLT *xscl, PLFLT *xoff, PLFLT *yscl, PLFLT *yoff));
  540. Xvoid sdp PLARGS((PLFLT xscl, PLFLT xoff, PLFLT yscl, PLFLT yoff));
  541. Xvoid gmp PLARGS((PLFLT *xscl, PLFLT *xoff, PLFLT *yscl,PLFLT *yoff));
  542. Xvoid smp PLARGS((PLFLT xscl, PLFLT xoff, PLFLT yscl, PLFLT yoff));
  543. Xvoid gchr PLARGS((PLFLT *def, PLFLT *ht));
  544. Xvoid schr PLARGS((PLFLT def, PLFLT ht));
  545. Xvoid gsym PLARGS((PLFLT *def, PLFLT *ht));
  546. Xvoid ssym PLARGS((PLFLT def, PLFLT ht));
  547. Xvoid gmaj PLARGS((PLFLT *def, PLFLT *ht));
  548. Xvoid smaj PLARGS((PLFLT def, PLFLT ht));
  549. Xvoid gmin PLARGS((PLFLT *def, PLFLT *ht));
  550. Xvoid smin PLARGS((PLFLT def, PLFLT ht));
  551. X
  552. X/* Functions that return floats */
  553. XPLFLT plstrl PLARGS((char *string));
  554. X/* Stuff in fcnvrt.c */
  555. XPLFLT dcmmx PLARGS((PLFLT x));
  556. XPLFLT dcmmy PLARGS((PLFLT y));
  557. XPLFLT dcscx PLARGS((PLFLT x));
  558. XPLFLT dcscy PLARGS((PLFLT y));
  559. XPLFLT mmdcx PLARGS((PLFLT x));
  560. XPLFLT mmdcy PLARGS((PLFLT y));
  561. XPLFLT scdcx PLARGS((PLFLT x));
  562. XPLFLT scdcy PLARGS((PLFLT y));
  563. XPLFLT wcmmx PLARGS((PLFLT x));
  564. XPLFLT wcmmy PLARGS((PLFLT y));
  565. XPLFLT w3wcx PLARGS((PLFLT x, PLFLT y, PLFLT z));
  566. XPLFLT w3wcy PLARGS((PLFLT x, PLFLT y, PLFLT z));
  567. X
  568. X/* Functions returning PLINTs */
  569. XPLINT plabv PLARGS((PLINT px, PLINT py, PLINT sx1, PLINT sy1, PLINT sx2, PLINT sy2));
  570. XPLINT plcvec PLARGS((PLINT ch, signed char **xygrid));
  571. XPLINT stindex PLARGS((char *str1, char *str2));
  572. XPLINT strpos PLARGS((char *str, char chr));
  573. XPLINT stsearch PLARGS((char *str, char chr));
  574. X/* This stuff is all in icnvrt.c */
  575. XPLINT dcpcx PLARGS((PLFLT x));
  576. XPLINT dcpcy PLARGS((PLFLT y));
  577. XPLINT mmpcx PLARGS((PLFLT x));
  578. XPLINT mmpcy PLARGS((PLFLT y));
  579. XPLINT wcpcx PLARGS((PLFLT x));
  580. XPLINT wcpcy PLARGS((PLFLT y));
  581. X
  582. X/* Device independent routines */
  583. Xvoid grsetup PLARGS((void));
  584. Xvoid grselect PLARGS((void));
  585. Xvoid grbeg PLARGS((PLINT dev));
  586. Xvoid grclr PLARGS((void));
  587. Xvoid grpage PLARGS((void));
  588. Xvoid grcol PLARGS((void));
  589. Xvoid grwid PLARGS((void));
  590. Xvoid grinit PLARGS((void));
  591. Xvoid grgra PLARGS((void));
  592. Xvoid grline PLARGS((PLINT x1, PLINT y1, PLINT x2, PLINT y2));
  593. Xvoid grtext PLARGS((void));
  594. Xvoid grtidy PLARGS((void));
  595. END_OF_FILE
  596. if test 13579 -ne `wc -c <'include/plplot.h'`; then
  597.     echo shar: \"'include/plplot.h'\" unpacked with wrong size!
  598. fi
  599. # end of 'include/plplot.h'
  600. fi
  601. if test -f 'src/plbox.c' -a "${1}" != "-c" ; then 
  602.   echo shar: Will not clobber existing file \"'src/plbox.c'\"
  603. else
  604. echo shar: Extracting \"'src/plbox.c'\" \(11587 characters\)
  605. sed "s/^X//" >'src/plbox.c' <<'END_OF_FILE'
  606. X/* This draws a box around the current viewport. XOPT and YOPT are */
  607. X/* character strings which define the box as follows: */
  608. X
  609. X/* A: Draw axis (X is horizontal line Y=0, Y is vertical line X=0) */
  610. X/* B: Draw bottom (X) or left (Y) edge of frame */
  611. X/* C: Draw top (X) or right (Y) edge of frame */
  612. X/* G: Draws a grid at the major tick interval */
  613. X/* I: Inverts tick marks */
  614. X/* L: Logarithmic axes, major ticks at decades, minor ticks at units */
  615. X/* N: Write numeric label at conventional location */
  616. X/* M: Write numeric label at unconventional location */
  617. X/* T: Draw major tick marks */
  618. X/* S: Draw minor tick marks */
  619. X/* V: (for Y only) Label vertically */
  620. X
  621. X/* xtick, ytick are the major tick intervals required, zero for  */
  622. X/*              automatic selection */
  623. X/* nxsub, nysub are the number of subtick intervals in a major tick */
  624. X/*              interval */
  625. X
  626. X#include "plplot.h"
  627. X#include <stdio.h>
  628. X#include <math.h>
  629. X#ifdef PLSTDC
  630. X#include <string.h>
  631. X#else
  632. Xextern char *strcat();
  633. Xextern char *strcpy();
  634. X#endif
  635. X
  636. X#define betw(c,a,b) ((a<=c && c<=b) || (b<=c && c<=a))
  637. X
  638. Xstatic PLFLT xlog[8] = {0.301030, 0.477121, 0.602060, 0.698970,
  639. X                        0.778151, 0.845098, 0.903090, 0.954243};
  640. X
  641. Xvoid plbox(xopt,xtick,nxsub,yopt,ytick,nysub)
  642. Xchar *xopt, *yopt;
  643. XPLFLT xtick, ytick;
  644. XPLINT nxsub, nysub;
  645. X{
  646. X      static char string[40];
  647. X      char strtmp[4];
  648. X      PLINT lax,lbx,lcx,lgx,lix,llx,lmx,lnx,lsx,ltx;
  649. X      PLINT lay,lby,lcy,lgy,liy,lly,lmy,lny,lsy,lty,lvy;
  650. X      PLINT xmajor, xminor, ymajor, yminor, xmode, xprec;
  651. X      PLINT ymode, yprec;
  652. X      PLINT i, i1x, i2x, i3x, i4x, i1y, i2y, i3y, i4y, it0;
  653. X      PLINT nxsub1, nysub1;
  654. X      PLINT lxmin, lxmax, lymin, lymax;
  655. X      PLINT pxmin, pxmax, pymin, pymax;
  656. X      PLINT vppxmi, vppxma, vppymi, vppyma;
  657. X      PLINT level;
  658. X      PLFLT xpmm, ypmm, defmaj, defmin, htmaj, htmin;
  659. X      PLFLT xtick1, ytick1, vpwxmi, vpwxma, vpwymi, vpwyma;
  660. X      PLFLT pos, tn, tp, temp;
  661. X
  662. X      glev(&level);
  663. X      if (level<3) plexit("Please set up window before calling plbox.");
  664. X
  665. X      /* Open  the clip limits to the subpage limits */
  666. X      gclp(&lxmin,&lxmax,&lymin,&lymax);
  667. X      gphy(&pxmin,&pxmax,&pymin,&pymax);
  668. X      sclp(pxmin,pxmax,pymin,pymax);
  669. X
  670. X      gvpp(&vppxmi,&vppxma,&vppymi,&vppyma);
  671. X
  672. X      /* Tick and subtick sizes in device coords */
  673. X      gpixmm(&xpmm,&ypmm);
  674. X      gmaj(&defmaj,&htmaj);
  675. X      gmin(&defmin,&htmin);
  676. X
  677. X      xmajor=max(round(htmaj*ypmm),1);
  678. X      ymajor=max(round(htmaj*xpmm),1);
  679. X      xminor=max(round(htmin*ypmm),1);
  680. X      yminor=max(round(htmin*xpmm),1);
  681. X
  682. X      xtick1=xtick;
  683. X      nxsub1=nxsub;
  684. X      ytick1=ytick;
  685. X      nysub1=nysub;
  686. X
  687. X      lax=stsearch(xopt,'a');
  688. X      lbx=stsearch(xopt,'b');
  689. X      lcx=stsearch(xopt,'c');
  690. X      lgx=stsearch(xopt,'g');
  691. X      lix=stsearch(xopt,'i');
  692. X      llx=stsearch(xopt,'l');
  693. X      lmx=stsearch(xopt,'m');
  694. X      lnx=stsearch(xopt,'n');
  695. X      lsx=stsearch(xopt,'s');
  696. X      ltx=stsearch(xopt,'t');
  697. X
  698. X      lay=stsearch(yopt,'a');
  699. X      lby=stsearch(yopt,'b');
  700. X      lcy=stsearch(yopt,'c');
  701. X      lgy=stsearch(yopt,'g');
  702. X      liy=stsearch(yopt,'i');
  703. X      lly=stsearch(yopt,'l');
  704. X      lmy=stsearch(yopt,'m');
  705. X      lny=stsearch(yopt,'n');
  706. X      lsy=stsearch(yopt,'s');
  707. X      lty=stsearch(yopt,'t');
  708. X      lvy=stsearch(yopt,'v');
  709. X
  710. X      gvpw(&vpwxmi,&vpwxma,&vpwymi,&vpwyma);
  711. X
  712. X      lax=lax && (vpwymi*vpwyma<0.0) && !llx;
  713. X      lay=lay && (vpwxmi*vpwxma<0.0) && !lly;
  714. X      if (llx) xtick1=1.0;
  715. X      if (lly) ytick1=1.0;
  716. X      if (ltx || lgx)
  717. X          pldtik(vpwxmi,vpwxma,&xtick1,&nxsub1,&xmode,&xprec);
  718. X      if (lty || lgy)
  719. X          pldtik(vpwymi,vpwyma,&ytick1,&nysub1,&ymode,&yprec);
  720. X
  721. X      /* Set up tick variables */
  722. X      if (lix) {
  723. X        i1x=xminor;
  724. X        i2x=0;
  725. X        i3x=xmajor;
  726. X        i4x=0;
  727. X      }
  728. X      else {
  729. X        i1x=0;
  730. X        i2x=xminor;
  731. X        i3x=0;
  732. X        i4x=xmajor;
  733. X      }
  734. X
  735. X      if (liy) {
  736. X        i1y=yminor;
  737. X        i2y=0;
  738. X        i3y=ymajor;
  739. X        i4y=0;
  740. X      }
  741. X      else {
  742. X        i1y=0;
  743. X        i2y=yminor;
  744. X        i3y=0;
  745. X        i4y=ymajor;
  746. X      }
  747. X
  748. X
  749. X      /* Draw the bottom edge of the box */
  750. X      if (lbx) {
  751. X        movphy(vppxmi,vppymi);
  752. X        if (ltx) {
  753. X          tp=xtick1*floor(vpwxmi/xtick1);
  754. X          for(;;) {
  755. X             tn=tp+xtick1;
  756. X             if (lsx) {
  757. X               if (llx) {
  758. X                 for(i=0; i<=7;i++){
  759. X                   temp=tp+xlog[i];
  760. X                   if (betw(temp,vpwxmi,vpwxma))
  761. X                        plxtik(wcpcx(temp),vppymi,i1x,i2x);
  762. X                 }
  763. X               }
  764. X               else {
  765. X                 for ( i=1;i<=nxsub1-1;i++) {
  766. X                   temp=tp+i*(tn-tp)/nxsub1;
  767. X                   if (betw(temp,vpwxmi,vpwxma))
  768. X                        plxtik(wcpcx(temp),vppymi,i1x,i2x);
  769. X                 }
  770. X               }
  771. X             }
  772. X             if (!betw(tn,vpwxmi,vpwxma))
  773. X               break;
  774. X             plxtik(wcpcx(tn),vppymi,i3x,i4x);
  775. X             tp=tn;
  776. X          }
  777. X        }
  778. X        draphy(vppxma,vppymi);
  779. X      }
  780. X
  781. X      /* Draw right-hand edge of box */
  782. X      if (lcy) {
  783. X        movphy(vppxma,vppymi);
  784. X        if (lty) {
  785. X          tp=ytick1*floor(vpwymi/ytick1);
  786. X          for(;;) {
  787. X             tn=tp+ytick1;
  788. X             if (lsy) {
  789. X               if (lly) {
  790. X                 for(i=0;i<=7;i++) {
  791. X                   temp=tp+xlog[i];
  792. X                   if (betw(temp,vpwymi,vpwyma))
  793. X                        plytik(vppxma,wcpcy(temp),i2y,i1y);
  794. X                 }
  795. X               }
  796. X               else {
  797. X                 for(i=1;i<=nysub1-1;i++) {
  798. X                   temp=tp+i*(tn-tp)/nysub1;
  799. X                   if (betw(temp,vpwymi,vpwyma))
  800. X                        plytik(vppxma,wcpcy(temp),i2y,i1y);
  801. X                 }
  802. X               }
  803. X             }
  804. X             if (!betw(tn,vpwymi,vpwyma))
  805. X                break;
  806. X             plytik(vppxma,wcpcy(tn),i4y,i3y);
  807. X             tp=tn;
  808. X          }
  809. X        }
  810. X        draphy(vppxma,vppyma);
  811. X      }
  812. X
  813. X      /* Draw the top edge of the box */
  814. X      if (lcx) {
  815. X        movphy(vppxma,vppyma);
  816. X        if (ltx) {
  817. X          tp=xtick1*(floor(vpwxma/xtick1)+1);
  818. X          for(;;) {
  819. X             tn=tp-xtick1;
  820. X             if (lsx) {
  821. X               if (llx) {
  822. X                 for(i=7;i>=0;i--) {
  823. X                   temp=tn+xlog[i];
  824. X                   if (betw(temp,vpwxmi,vpwxma))
  825. X                        plxtik(wcpcx(temp),vppyma,i2x,i1x);
  826. X                 }
  827. X               }
  828. X               else {
  829. X                 for(i=nxsub1-1;i>=1;i--) {
  830. X                   temp=tn+i*(tp-tn)/nxsub1;
  831. X                   if (betw(temp,vpwxmi,vpwxma))
  832. X                        plxtik(wcpcx(temp),vppyma,i2x,i1x);
  833. X                 }
  834. X               }
  835. X             }
  836. X             if (!betw(tn,vpwxmi,vpwxma))
  837. X               break;
  838. X             plxtik(wcpcx(tn),vppyma,i4x,i3x);
  839. X             tp=tn;
  840. X          }
  841. X        }
  842. X        draphy(vppxmi,vppyma);
  843. X      }
  844. X
  845. X      /* Draw left-hand edge of box */
  846. X      if (lby) {
  847. X        movphy(vppxmi,vppyma);
  848. X        if (lty) {
  849. X          tp=ytick1*(floor(vpwyma/ytick1)+1);
  850. X          for(;;) {
  851. X             tn=tp-ytick1;
  852. X             if (lsy) {
  853. X               if (lly) {
  854. X                 for(i=7;i>=0;i--) {
  855. X                   temp=tn+xlog[i];
  856. X                   if (betw(temp,vpwymi,vpwyma))
  857. X                        plytik(vppxmi,wcpcy(temp),i1y,i2y);
  858. X                 }
  859. X               }
  860. X               else {
  861. X                 for(i=nysub1-1;i>=1;i--) {
  862. X                   temp=tn+i*(tp-tn)/nysub1;
  863. X                   if (betw(temp,vpwymi,vpwyma))
  864. X                        plytik(vppxmi,wcpcy(temp),i1y,i2y);
  865. X                 }
  866. X               }
  867. X             }
  868. X             if (!betw(tn,vpwymi,vpwyma))
  869. X               break;
  870. X             plytik(vppxmi,wcpcy(tn),i3y,i4y);
  871. X             tp=tn;
  872. X          }
  873. X        }
  874. X        draphy(vppxmi,vppymi);
  875. X      }
  876. X
  877. X      /* Draw the horizontal axis */
  878. X      if (lax) {
  879. X        it0=wcpcy((PLFLT)0.0);
  880. X        movphy(vppxmi,it0);
  881. X        if (ltx) {
  882. X          tp=xtick1*floor(vpwxmi/xtick1);
  883. X          for(;;) {
  884. X             tn=tp+xtick1;
  885. X             if (lsx) {
  886. X               if (llx) {
  887. X                 for(i=0;i<=7;i++) {
  888. X                   temp=tp+xlog[i];
  889. X                   if (betw(temp,vpwxmi,vpwxma))
  890. X                        plxtik(wcpcx(temp),it0,xminor,xminor);
  891. X                 }
  892. X               }
  893. X               else {
  894. X                 for(i=1;i<=nxsub1-1;i++) {
  895. X                   temp=tp+i*(tn-tp)/nxsub1;
  896. X                   if (betw(temp,vpwxmi,vpwxma))
  897. X                        plxtik(wcpcx(temp),it0,xminor,xminor);
  898. X                 }
  899. X               }
  900. X             }
  901. X             if (!betw(tn,vpwxmi,vpwxma))
  902. X               break;
  903. X             plxtik(wcpcx(tn),it0,xmajor,xmajor);
  904. X             tp=tn;
  905. X          }
  906. X        }
  907. X        draphy(vppxma,it0);
  908. X      }
  909. X
  910. X      /* Draw the vertical axis */
  911. X      if (lay) {
  912. X        it0=wcpcx((PLFLT)0.0);
  913. X        movphy(it0,vppymi);
  914. X        if (lty) {
  915. X          tp=ytick1*floor(vpwymi/ytick1);
  916. X          for(;;) {
  917. X             tn=tp+ytick1;
  918. X             if (lsy) {
  919. X               if (lly) {
  920. X                 for(i=0;i<=7;i++) {
  921. X                   temp=tp+xlog[i];
  922. X                   if (betw(temp,vpwymi,vpwyma))
  923. X                      plytik(it0,wcpcy(temp),yminor,yminor);
  924. X                 }
  925. X               }
  926. X               else {
  927. X                 for(i=1;i<=nysub1-1;i++) {
  928. X                   temp=tp+i*(tn-tp)/nysub1;
  929. X                   if (betw(temp,vpwymi,vpwyma))
  930. X                        plytik(it0,wcpcy(temp),yminor,yminor);
  931. X                 }
  932. X               }
  933. X             }
  934. X             if (!betw(tn,vpwymi,vpwyma))
  935. X               break;
  936. X             plytik(it0,wcpcy(tn),ymajor,ymajor);
  937. X             tp=tn;
  938. X          }
  939. X        }
  940. X        draphy(it0,vppyma);
  941. X      }
  942. X
  943. X      /* Draw grid in x direction */
  944. X      if (lgx) {
  945. X        tp=xtick1*(1.+floor(vpwxmi/xtick1+.5));
  946. X        for(tn=tp; betw(tn+xtick1/2.,vpwxmi,vpwxma); tn+=xtick1)
  947. X           pljoin(tn,vpwymi,tn,vpwyma);
  948. X      }
  949. X
  950. X      /* Draw grid in y direction */
  951. X      if (lgy) {
  952. X        tp=ytick1*(1.+floor(vpwymi/ytick1+.5));
  953. X        for(tn=tp; betw(tn+ytick1/2.,vpwymi,vpwyma); tn+=ytick1)
  954. X           pljoin(vpwxmi,tn,vpwxma,tn);
  955. X      }
  956. X
  957. X      /* Write horizontal label(s) */
  958. X      if ((lmx || lnx) && ltx) {
  959. X        tp=xtick1*(1.+floor(vpwxmi/xtick1));
  960. X        for(tn=tp; betw(tn,vpwxmi,vpwxma); tn+=xtick1) {
  961. X          if (!llx)
  962. X            plform(tn,xmode,xprec,string);
  963. X          else {
  964. X            sprintf(strtmp,"%-d",round(tn));
  965. X            strcpy(string,"10#u");
  966. X            strcat(string,strtmp);
  967. X          }
  968. X          pos=(tn-vpwxmi)/(vpwxma-vpwxmi);
  969. X          if (lnx) plmtex("b",(PLFLT)1.5,pos,(PLFLT)0.5,string);
  970. X          if (lmx) plmtex("t",(PLFLT)1.5,pos,(PLFLT)0.5,string);
  971. X        }
  972. X      }
  973. X
  974. X      /* Write vertical label(s) */
  975. X      if ((lmy || lny) && lty) {
  976. X        tp=ytick1*(1.+floor(vpwymi/ytick1));
  977. X        for(tn=tp; betw(tn,vpwymi,vpwyma); tn+=ytick1) {
  978. X          if (!lly)
  979. X            plform(tn,ymode,yprec,string);
  980. X          else {
  981. X            sprintf(strtmp,"%-d",round(tn));
  982. X            strcpy(string,"10#u");
  983. X            strcat(string,strtmp);
  984. X          }
  985. X          pos=(tn-vpwymi)/(vpwyma-vpwymi);
  986. X          if (lny) {
  987. X            if (lvy)
  988. X              plmtex("lv",(PLFLT)0.5,pos,(PLFLT)1.0,string);
  989. X            else
  990. X              plmtex("l",(PLFLT)1.5,pos,(PLFLT)0.5,string);
  991. X          }
  992. X          if (lmy) {
  993. X            if (lvy)
  994. X              plmtex("rv",(PLFLT)0.5,pos,(PLFLT)0.0,string);
  995. X            else
  996. X              plmtex("r",(PLFLT)1.5,pos,(PLFLT)0.5,string);
  997. X          }
  998. X        }
  999. X      }
  1000. X      /* Restore the clip limits to viewport edge */
  1001. X      sclp(lxmin,lxmax,lymin,lymax);
  1002. X}
  1003. END_OF_FILE
  1004. if test 11587 -ne `wc -c <'src/plbox.c'`; then
  1005.     echo shar: \"'src/plbox.c'\" unpacked with wrong size!
  1006. fi
  1007. # end of 'src/plbox.c'
  1008. fi
  1009. if test -f 'src/plnxtv.c' -a "${1}" != "-c" ; then 
  1010.   echo shar: Will not clobber existing file \"'src/plnxtv.c'\"
  1011. else
  1012. echo shar: Extracting \"'src/plnxtv.c'\" \(16101 characters\)
  1013. sed "s/^X//" >'src/plnxtv.c' <<'END_OF_FILE'
  1014. X/* Draws the next view of a 3-d plot. The physical coordinates of */
  1015. X/* the points for the next view are placed in the n points of arrays  */
  1016. X/* u and v. The silhouette found so far is stored in the heap as a */
  1017. X/* set of m peak points. */
  1018. X
  1019. X#include "plplot.h"
  1020. X#include "declare.h"
  1021. X#include <stdio.h>
  1022. X#ifdef PLSTDC
  1023. X#include <stdlib.h>
  1024. X#else
  1025. Xextern char *malloc();
  1026. Xextern char *realloc();
  1027. Xextern void free();
  1028. X#endif
  1029. X
  1030. XPLINT pl3mode=0;                 /* 0 3d solid; 1 mesh plot */
  1031. XPLINT pl3upv=1;                  /* 1 update view; 0 no update */
  1032. XPLINT *oldhiview;
  1033. XPLINT *oldloview;
  1034. X
  1035. X/* This routine now dynamically allocates the memory it needs for hidden */
  1036. X/* line removal.  Memory is allocated in blocks of 2*BINC*sizeof(PLINT) */
  1037. X/* bytes.  Large values of BINC give better performance but also */
  1038. X/* allocate more memory than is needed. If your 3D plots are very */
  1039. X/* "spiky" or you are working with very large matrices then you will */
  1040. X/* probably want to increase BINC. */
  1041. X
  1042. X#define  BINC      50
  1043. X
  1044. Xstatic PLINT *newhiview;
  1045. Xstatic PLINT *newloview;
  1046. Xstatic PLINT mhi, xxhi, newhisize;
  1047. Xstatic PLINT mlo, xxlo, newlosize;
  1048. X
  1049. Xvoid plnxtv(u, v, n, init)
  1050. XPLINT *u, *v, n, init;
  1051. X{
  1052. X   void plnxtvhi(), plnxtvlo();
  1053. X
  1054. X   plnxtvhi(u,v,n,init);
  1055. X
  1056. X   if(pl3mode)
  1057. X      plnxtvlo(u,v,n,init);
  1058. X}
  1059. X
  1060. Xstatic void plnxtvhi(u,v,n,init)
  1061. XPLINT *u, *v, n, init;
  1062. X{
  1063. X      PLINT i, j, first;
  1064. X      PLINT sx1, sx2, sy1, sy2;
  1065. X      PLINT su1, su2, sv1, sv2;
  1066. X      PLINT cx, cy, px, py;
  1067. X      PLINT seg, ptold, lstold, pthi, pnewhi, newhi, change, ochange;
  1068. X      void savehipoint(), swaphiview();
  1069. X
  1070. X      first = 1;
  1071. X      pnewhi = 0;
  1072. X
  1073. X      /* For the initial set of points, just display them and store them as */
  1074. X      /* the peak points. */
  1075. X
  1076. X      if (init == 1) {
  1077. X         /* heap not yet allocated so ... */
  1078. X         if(!( oldhiview = (PLINT *)malloc(2*n*sizeof(PLINT))))
  1079. X            plexit("Out of memory.");
  1080. X         movphy(u[0],v[0]);
  1081. X         oldhiview[0] = u[0];
  1082. X         oldhiview[1] = v[0];
  1083. X         for (i=1; i<n; i++){
  1084. X           draphy(u[i],v[i]);
  1085. X           oldhiview[2*i] = u[i];
  1086. X           oldhiview[2*i+1] = v[i];
  1087. X         }
  1088. X         mhi = n;
  1089. X         return;
  1090. X      }
  1091. X
  1092. X      /* Otherwise, we need to consider hidden-line removal problem. We scan */
  1093. X      /* over the points in both the old (i.e. oldhiview[]) and */
  1094. X      /* new (i.e. u[] and v[]) arrays in order of increasing x coordinate. */
  1095. X      /* At each stage, we find the line segment in the other array (if one */
  1096. X      /* exists) that straddles the x coordinate of the point. We */
  1097. X      /* have to determine if the point lies above or below the line segment, */
  1098. X      /* and to check if the below/above status has changed since the last */
  1099. X      /* point. */
  1100. X
  1101. X      /* If pl3upv = 0 we do not update the view, this is useful for drawing */
  1102. X      /* lines on the graph after we are done plotting points.  Hidden line */
  1103. X      /* removal is still done, but the view is not updated. */
  1104. X      xxhi = 0;
  1105. X      i = 0;
  1106. X      j = 0;
  1107. X      if(pl3upv != 0) {
  1108. X         newhisize = 2*(mhi+BINC);
  1109. X         if(!( newhiview = (PLINT *)malloc(newhisize*sizeof(PLINT)))) {
  1110. X            free((VOID *)oldhiview);
  1111. X            plexit("Out of memory.");
  1112. X         }
  1113. X      }
  1114. X
  1115. X      /* (oldhiview[2*i], oldhiview[2*i]) is the i'th point in the old array */
  1116. X      /* (u[j], v[j])           is the j'th point in the new array */
  1117. X
  1118. X      while (i < mhi || j < n) {
  1119. X
  1120. X        /* The coordinates of the point under consideration are (px,py). */
  1121. X        /* The line segment joins (sx1,sy1) to (sx2,sy2). */
  1122. X
  1123. X        /* "ptold" is true if the point lies in the old array. We set it */
  1124. X        /*  by comparing the x coordinates of the i'th old point */
  1125. X        /*  and the j'th new point, being careful if we have fallen past */
  1126. X        /*  the edges. Having found the point, load up the point and */
  1127. X        /*  segment coordinates appropriately. */
  1128. X
  1129. X        ptold = ((oldhiview[2*i] < u[j] && i<mhi) || j>= n);
  1130. X        if (ptold) {
  1131. X          px = oldhiview[2*i];
  1132. X          py = oldhiview[2*i+1];
  1133. X          seg = j>0 && j<n;
  1134. X          if (seg) {
  1135. X            sx1 = u[j-1];
  1136. X            sy1 = v[j-1];
  1137. X            sx2 = u[j];
  1138. X            sy2 = v[j];
  1139. X          }
  1140. X        }
  1141. X        else {
  1142. X          px = u[j];
  1143. X          py = v[j];
  1144. X          seg = i>0 && i<mhi;
  1145. X          if (seg) {
  1146. X            sx1 = oldhiview[2*(i-1)];
  1147. X            sy1 = oldhiview[2*(i-1)+1];
  1148. X            sx2 = oldhiview[2*i];
  1149. X            sy2 = oldhiview[2*i+1];
  1150. X          }
  1151. X        }
  1152. X
  1153. X        /* Now determine if the point is higher than the segment, using the */
  1154. X        /* logical function "above". We also need to know if it is */
  1155. X        /* the old view or the new view that is higher. "newhi" is set true */
  1156. X        /* if the new view is higher than the old */
  1157. X
  1158. X        if(seg)
  1159. X            pthi = plabv(px,py,sx1,sy1,sx2,sy2);
  1160. X        else
  1161. X            pthi = 1;
  1162. X
  1163. X        newhi = (ptold && !pthi) || (!ptold && pthi);
  1164. X        change = (newhi && !pnewhi) || (!newhi && pnewhi);
  1165. X
  1166. X        /* There is a new intersection point to put in the peak array if the */
  1167. X        /* state of "newhi" changes */
  1168. X
  1169. X        if (first) {
  1170. X          movphy(px,py);
  1171. X          first = 0;
  1172. X          lstold = ptold;
  1173. X          savehipoint(px,py);
  1174. X          pthi = 0;
  1175. X          ochange = 0;
  1176. X        }
  1177. X        else if (change) {
  1178. X          /* Take care of special cases at end of arrays.  If pl3upv */
  1179. X          /* is 0 the endpoints are not connected to the old view. */
  1180. X          if (pl3upv==0 && ((!ptold && j==0)||(ptold && i==0))) {
  1181. X            movphy(px,py);
  1182. X            lstold = ptold;
  1183. X            pthi = 0;
  1184. X            ochange = 0;
  1185. X          }
  1186. X          else if (pl3upv==0 && ((!ptold && i>=mhi)||(ptold && j>=n))) {
  1187. X            movphy(px,py);
  1188. X            lstold = ptold;
  1189. X            pthi = 0;
  1190. X            ochange = 0;
  1191. X          }
  1192. X          /* If pl3upv is not 0 then we do want to connect the current line */
  1193. X          /* with the previous view at the endpoints.  */
  1194. X          /* Also find intersection point with old view. */
  1195. X          else  {
  1196. X            if (i == 0) {
  1197. X              sx1 = oldhiview[0];
  1198. X              sy1 = -1;
  1199. X              sx2 = oldhiview[0];
  1200. X              sy2 = oldhiview[1];
  1201. X            }
  1202. X            else if (i >= mhi) {
  1203. X              sx1 = oldhiview[2*(mhi-1)];
  1204. X              sy1 = oldhiview[2*(mhi-1)+1];
  1205. X              sx2 = oldhiview[2*(mhi-1)];
  1206. X              sy2 = -1;
  1207. X            }
  1208. X            else {
  1209. X              sx1 = oldhiview[2*(i-1)];
  1210. X              sy1 = oldhiview[2*(i-1)+1];
  1211. X              sx2 = oldhiview[2*i];
  1212. X              sy2 = oldhiview[2*i+1];
  1213. X            }
  1214. X
  1215. X            if (j == 0) {
  1216. X              su1 = u[0];
  1217. X              sv1 = -1;
  1218. X              su2 = u[0];
  1219. X              sv2 = v[0];
  1220. X            }
  1221. X            else if (j >= n) {
  1222. X              su1 = u[n-1];
  1223. X              sv1 = v[n-1];
  1224. X              su2 = u[n];
  1225. X              sv2 = -1;
  1226. X            }
  1227. X            else  {
  1228. X              su1 = u[j-1];
  1229. X              sv1 = v[j-1];
  1230. X              su2 = u[j];
  1231. X              sv2 = v[j];
  1232. X            }
  1233. X
  1234. X            /* Determine the intersection */
  1235. X            pl3cut(sx1,sy1,sx2,sy2,su1,sv1,su2,sv2,&cx,&cy);
  1236. X            if (cx == px && cy == py)  {
  1237. X              if (lstold && !ochange)
  1238. X                movphy(px,py);
  1239. X              else
  1240. X                draphy(px,py);
  1241. X
  1242. X              savehipoint(px,py);
  1243. X              lstold = 1;
  1244. X              pthi = 0;
  1245. X            }
  1246. X            else {
  1247. X              if (lstold && !ochange)
  1248. X                 movphy(cx,cy);
  1249. X              else
  1250. X                 draphy(cx,cy);
  1251. X
  1252. X              lstold = 1;
  1253. X              savehipoint(cx,cy);
  1254. X            }
  1255. X            ochange =1;
  1256. X          }
  1257. X        }
  1258. X
  1259. X        /* If point is high then draw plot to point and update view. */
  1260. X        if (pthi) {
  1261. X          if (lstold && ptold)
  1262. X            movphy(px,py);
  1263. X          else
  1264. X            draphy(px,py);
  1265. X
  1266. X          savehipoint(px,py);
  1267. X          lstold = ptold;
  1268. X          ochange = 0;
  1269. X        }
  1270. X
  1271. X        pnewhi = newhi;
  1272. X
  1273. X        if (ptold)
  1274. X          i = i+1;
  1275. X        else
  1276. X          j = j+1;
  1277. X      }
  1278. X
  1279. X      /* Set oldhiview */
  1280. X      swaphiview();
  1281. X}
  1282. X
  1283. Xstatic void savehipoint(px, py)
  1284. XPLINT px, py;
  1285. X{
  1286. X   PLINT *temp;
  1287. X
  1288. X   if(pl3upv == 0)
  1289. X      return;
  1290. X   if( xxhi >= newhisize )  {
  1291. X      /* allocate additional space */
  1292. X      newhisize += 2*BINC;
  1293. X      if(!(temp = (PLINT *)realloc((VOID *)newhiview,newhisize*sizeof(PLINT)))) {
  1294. X         free((VOID *)oldhiview);
  1295. X         free((VOID *)newhiview);
  1296. X         plexit("Out of memory.");
  1297. X      }
  1298. X      newhiview = temp;
  1299. X   }
  1300. X
  1301. X   newhiview[xxhi] = px;
  1302. X   xxhi++;
  1303. X   newhiview[xxhi] = py;
  1304. X   xxhi++;
  1305. X}
  1306. X
  1307. Xstatic void swaphiview()
  1308. X{
  1309. X   if(pl3upv != 0) {
  1310. X     mhi = xxhi/2;
  1311. X     free((VOID *)oldhiview);
  1312. X     oldhiview = newhiview;
  1313. X   }
  1314. X}
  1315. X
  1316. Xstatic void plnxtvlo(u,v,n,init)
  1317. XPLINT *u, *v, n, init;
  1318. X{
  1319. X      PLINT i, j, first;
  1320. X      PLINT sx1, sx2, sy1, sy2;
  1321. X      PLINT su1, su2, sv1, sv2;
  1322. X      PLINT cx, cy, px, py;
  1323. X      PLINT seg, ptold, lstold, ptlo, pnewlo, newlo, change, ochange;
  1324. X      void savelopoint(), swaploview();
  1325. X
  1326. X      first = 1;
  1327. X      pnewlo = 0;
  1328. X
  1329. X      /* For the initial set of points, just display them and store them as */
  1330. X      /* the peak points. */
  1331. X
  1332. X      if (init == 1) {
  1333. X         /* heap not yet allocated so ... */
  1334. X         if(!( oldloview = (PLINT *)malloc(2*n*sizeof(PLINT))))
  1335. X            plexit("Out of memory.");
  1336. X         movphy(u[0],v[0]);
  1337. X         oldloview[0] = u[0];
  1338. X         oldloview[1] = v[0];
  1339. X         for (i=1; i<n; i++){
  1340. X           draphy(u[i],v[i]);
  1341. X           oldloview[2*i] = u[i];
  1342. X           oldloview[2*i+1] = v[i];
  1343. X         }
  1344. X         mlo = n;
  1345. X         return;
  1346. X      }
  1347. X
  1348. X      /* Otherwise, we need to consider hidden-line removal problem. We scan */
  1349. X      /* over the points in both the old (i.e. oldloview[]) and */
  1350. X      /* new (i.e. u[] and v[]) arrays in order of increasing x coordinate. */
  1351. X      /* At each stage, we find the line segment in the other array (if one */
  1352. X      /* exists) that straddles the x coordinate of the point. We */
  1353. X      /* have to determine if the point lies above or below the line segment, */
  1354. X      /* and to check if the below/above status has changed since the last */
  1355. X      /* point. */
  1356. X
  1357. X      /* If pl3upv = 0 we do not update the view, this is useful for drawing */
  1358. X      /* lines on the graph after we are done plotting points.  Hidden line */
  1359. X      /* removal is still done, but the view is not updated. */
  1360. X      xxlo = 0;
  1361. X      i = 0;
  1362. X      j = 0;
  1363. X      if(pl3upv != 0) {
  1364. X         newlosize = 2*(mlo+BINC);
  1365. X         if(!( newloview = (PLINT *)malloc(newlosize*sizeof(PLINT)))) {
  1366. X            free((VOID *)oldloview);
  1367. X            plexit("Out of memory.");
  1368. X         }
  1369. X      }
  1370. X
  1371. X      /* (oldloview[2*i], oldloview[2*i]) is the i'th point in the old array */
  1372. X      /* (u[j], v[j])           is the j'th point in the new array */
  1373. X
  1374. X      while (i < mlo || j < n) {
  1375. X
  1376. X        /* The coordinates of the point under consideration are (px,py). */
  1377. X        /* The line segment joins (sx1,sy1) to (sx2,sy2). */
  1378. X
  1379. X        /* "ptold" is true if the point lies in the old array. We set it */
  1380. X        /*  by comparing the x coordinates of the i'th old point */
  1381. X        /*  and the j'th new point, being careful if we have fallen past */
  1382. X        /*  the edges. Having found the point, load up the point and */
  1383. X        /*  segment coordinates appropriately. */
  1384. X
  1385. X        ptold = ((oldloview[2*i] < u[j] && i<mlo) || j>= n);
  1386. X        if (ptold) {
  1387. X          px = oldloview[2*i];
  1388. X          py = oldloview[2*i+1];
  1389. X          seg = j>0 && j<n;
  1390. X          if (seg) {
  1391. X            sx1 = u[j-1];
  1392. X            sy1 = v[j-1];
  1393. X            sx2 = u[j];
  1394. X            sy2 = v[j];
  1395. X          }
  1396. X        }
  1397. X        else {
  1398. X          px = u[j];
  1399. X          py = v[j];
  1400. X          seg = i>0 && i<mlo;
  1401. X          if (seg) {
  1402. X            sx1 = oldloview[2*(i-1)];
  1403. X            sy1 = oldloview[2*(i-1)+1];
  1404. X            sx2 = oldloview[2*i];
  1405. X            sy2 = oldloview[2*i+1];
  1406. X          }
  1407. X        }
  1408. X
  1409. X        /* Now determine if the point is lower than the segment, using the */
  1410. X        /* logical function "above". We also need to know if it is */
  1411. X        /* the old view or the new view that is lower. "newlo" is set true */
  1412. X        /* if the new view is lower than the old */
  1413. X
  1414. X        if(seg)
  1415. X            ptlo = !plabv(px,py,sx1,sy1,sx2,sy2);
  1416. X        else
  1417. X            ptlo = 1;
  1418. X
  1419. X        newlo = (ptold && !ptlo) || (!ptold && ptlo);
  1420. X        change = (newlo && !pnewlo) || (!newlo && pnewlo);
  1421. X
  1422. X        /* There is a new intersection point to put in the peak array if the */
  1423. X        /* state of "newlo" changes */
  1424. X
  1425. X        if (first) {
  1426. X          movphy(px,py);
  1427. X          first = 0;
  1428. X          lstold = ptold;
  1429. X          savelopoint(px,py);
  1430. X          ptlo = 0;
  1431. X          ochange = 0;
  1432. X        }
  1433. X        else if (change) {
  1434. X          /* Take care of special cases at end of arrays.  If pl3upv */
  1435. X          /* is 0 the endpoints are not connected to the old view. */
  1436. X          if (pl3upv==0 && ((!ptold && j==0)||(ptold && i==0))) {
  1437. X            movphy(px,py);
  1438. X            lstold = ptold;
  1439. X            ptlo = 0;
  1440. X            ochange = 0;
  1441. X          }
  1442. X          else if (pl3upv==0 && ((!ptold && i>=mlo)||(ptold && j>=n))) {
  1443. X            movphy(px,py);
  1444. X            lstold = ptold;
  1445. X            ptlo = 0;
  1446. X            ochange = 0;
  1447. X          }
  1448. X          /* If pl3upv is not 0 then we do want to connect the current line */
  1449. X          /* with the previous view at the endpoints.  */
  1450. X          /* Also find intersection point with old view. */
  1451. X          else  {
  1452. X            if (i == 0) {
  1453. X              sx1 = oldloview[0];
  1454. X              sy1 = 100000;
  1455. X              sx2 = oldloview[0];
  1456. X              sy2 = oldloview[1];
  1457. X            }
  1458. X            else if (i >= mlo) {
  1459. X              sx1 = oldloview[2*(mlo-1)];
  1460. X              sy1 = oldloview[2*(mlo-1)+1];
  1461. X              sx2 = oldloview[2*(mlo-1)];
  1462. X              sy2 = 100000;
  1463. X            }
  1464. X            else {
  1465. X              sx1 = oldloview[2*(i-1)];
  1466. X              sy1 = oldloview[2*(i-1)+1];
  1467. X              sx2 = oldloview[2*i];
  1468. X              sy2 = oldloview[2*i+1];
  1469. X            }
  1470. X
  1471. X            if (j == 0) {
  1472. X              su1 = u[0];
  1473. X              sv1 = 100000;
  1474. X              su2 = u[0];
  1475. X              sv2 = v[0];
  1476. X            }
  1477. X            else if (j >= n) {
  1478. X              su1 = u[n-1];
  1479. X              sv1 = v[n-1];
  1480. X              su2 = u[n];
  1481. X              sv2 = 100000;
  1482. X            }
  1483. X            else  {
  1484. X              su1 = u[j-1];
  1485. X              sv1 = v[j-1];
  1486. X              su2 = u[j];
  1487. X              sv2 = v[j];
  1488. X            }
  1489. X
  1490. X            /* Determine the intersection */
  1491. X            pl3cut(sx1,sy1,sx2,sy2,su1,sv1,su2,sv2,&cx,&cy);
  1492. X            if (cx == px && cy == py)  {
  1493. X              if (lstold && !ochange)
  1494. X                movphy(px,py);
  1495. X              else
  1496. X                draphy(px,py);
  1497. X
  1498. X              savelopoint(px,py);
  1499. X              lstold = 1;
  1500. X              ptlo = 0;
  1501. X            }
  1502. X            else {
  1503. X              if (lstold && !ochange)
  1504. X                 movphy(cx,cy);
  1505. X              else
  1506. X                 draphy(cx,cy);
  1507. X
  1508. X              lstold = 1;
  1509. X              savelopoint(cx,cy);
  1510. X            }
  1511. X            ochange =1;
  1512. X          }
  1513. X        }
  1514. X
  1515. X        /* If point is low then draw plot to point and update view. */
  1516. X        if (ptlo) {
  1517. X          if (lstold && ptold)
  1518. X            movphy(px,py);
  1519. X          else
  1520. X            draphy(px,py);
  1521. X
  1522. X          savelopoint(px,py);
  1523. X          lstold = ptold;
  1524. X          ochange = 0;
  1525. X        }
  1526. X
  1527. X        pnewlo = newlo;
  1528. X
  1529. X        if (ptold)
  1530. X          i = i+1;
  1531. X        else
  1532. X          j = j+1;
  1533. X      }
  1534. X
  1535. X      /* Set oldloview */
  1536. X      swaploview();
  1537. X}
  1538. X
  1539. Xstatic void savelopoint(px, py)
  1540. XPLINT px, py;
  1541. X{
  1542. X   PLINT *temp;
  1543. X
  1544. X   if(pl3upv == 0)
  1545. X      return;
  1546. X   if( xxlo >= newlosize )  {
  1547. X      /* allocate additional space */
  1548. X      newlosize += 2*BINC;
  1549. X      if(!(temp = (PLINT *)realloc((VOID *)newloview,newlosize*sizeof(PLINT)))) {
  1550. X         free((VOID *)oldloview);
  1551. X         free((VOID *)newloview);
  1552. X         plexit("Out of memory.");
  1553. X      }
  1554. X      newloview = temp;
  1555. X   }
  1556. X
  1557. X   newloview[xxlo] = px;
  1558. X   xxlo++;
  1559. X   newloview[xxlo] = py;
  1560. X   xxlo++;
  1561. X}
  1562. X
  1563. Xstatic void swaploview()
  1564. X{
  1565. X   if(pl3upv != 0) {
  1566. X     mlo = xxlo/2;
  1567. X     free((VOID *)oldloview);
  1568. X     oldloview = newloview;
  1569. X   }
  1570. X}
  1571. X
  1572. X
  1573. X
  1574. END_OF_FILE
  1575. if test 16101 -ne `wc -c <'src/plnxtv.c'`; then
  1576.     echo shar: \"'src/plnxtv.c'\" unpacked with wrong size!
  1577. fi
  1578. # end of 'src/plnxtv.c'
  1579. fi
  1580. echo shar: End of archive 7 \(of 12\).
  1581. cp /dev/null ark7isdone
  1582. MISSING=""
  1583. for I in 1 2 3 4 5 6 7 8 9 10 11 12 ; do
  1584.     if test ! -f ark${I}isdone ; then
  1585.     MISSING="${MISSING} ${I}"
  1586.     fi
  1587. done
  1588. if test "${MISSING}" = "" ; then
  1589.     echo You have unpacked all 12 archives.
  1590.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1591. else
  1592.     echo You still need to unpack the following archives:
  1593.     echo "        " ${MISSING}
  1594. fi
  1595. ##  End of shell archive.
  1596. exit 0
  1597. -- 
  1598. Submissions to comp.sources.amiga and comp.binaries.amiga should be sent to:
  1599.     amiga@cs.odu.edu    
  1600. or    amiga@xanth.cs.odu.edu    ( obsolescent mailers may need this address )
  1601. or    ...!uunet!xanth!amiga    ( very obsolescent mailers need this address )
  1602.  
  1603. Comments, questions, and suggestions s should be addressed to ``amiga-request''
  1604. (only use ``amiga'' for submissions) at the above addresses.
  1605.